/**
 * 企业微信JSSDK集成模块
 * 处理企业微信环境检测、JSSDK初始化和用户身份获取
 */

// 企业微信服务类
class WeChatWorkService {
    constructor() {
        this.isInitialized = false;
        this.isInWeChatWork = this.detectWeChatWorkEnvironment();
        this.config = null;
        this.userInfo = null;
        
        // 事件监听器
        this.listeners = {
            ready: [],
            error: [],
            userInfoReady: []
        };
        
        window.AppUtils.log('企业微信服务初始化', {
            isInWeChatWork: this.isInWeChatWork,
            userAgent: navigator.userAgent
        });
    }
    
    /**
     * 检测是否在企业微信环境中
     * @returns {boolean} 是否在企业微信环境
     */
    detectWeChatWorkEnvironment() {
        const ua = navigator.userAgent.toLowerCase();
        
        // 检测企业微信标识
        const isWxWork = /wxwork/i.test(ua) || /micromessenger/i.test(ua);
        
        // 检测更具体的企业微信标识
        const hasWxWorkFlag = ua.includes('wxwork') || 
                             ua.includes('wechatwork') || 
                             (ua.includes('micromessenger') && ua.includes('windowswechat'));
        
        window.AppUtils.log('环境检测结果:', {
            userAgent: ua,
            isWxWork: isWxWork,
            hasWxWorkFlag: hasWxWorkFlag
        });
        
        return isWxWork || hasWxWorkFlag;
    }
    
    /**
     * 初始化企业微信JSSDK
     * @param {Object} options - 初始化选项
     * @returns {Promise} 初始化Promise
     */
    async initialize(options = {}) {
        if (this.isInitialized) {
            window.AppUtils.log('JSSDK已经初始化');
            return Promise.resolve();
        }
        
        try {
            // 检查是否在企业微信环境中
            if (!this.isInWeChatWork && !window.AppConfig.development.enableMockData) {
                throw new Error('当前不在企业微信环境中');
            }
            
            // 等待企业微信JSSDK加载
            await this.waitForWxSDK();
            
            // 获取JSSDK配置
            const config = await this.getJsSdkConfig();
            
            // 配置JSSDK
            await this.configureJsSDK(config);
            
            this.isInitialized = true;
            this.config = config;
            
            // 触发ready事件
            this.emit('ready', config);
            
            window.AppUtils.log('企业微信JSSDK初始化成功');
            
            return config;
        } catch (error) {
            window.AppUtils.error('企业微信JSSDK初始化失败:', error);
            this.emit('error', error);
            throw error;
        }
    }
    
    /**
     * 等待企业微信SDK加载
     * @returns {Promise} 等待Promise
     */
    waitForWxSDK() {
        return new Promise((resolve, reject) => {
            // 如果是模拟环境，直接resolve
            if (window.AppConfig.development.enableMockData) {
                // 模拟wx对象
                if (!window.wx) {
                    window.wx = this.createMockWxObject();
                }
                resolve();
                return;
            }
            
            // 检查wx对象是否已存在
            if (window.wx && window.wx.config) {
                resolve();
                return;
            }
            
            // 等待wx对象加载
            let attempts = 0;
            const maxAttempts = 50; // 最多等待5秒
            
            const checkWx = () => {
                attempts++;
                
                if (window.wx && window.wx.config) {
                    resolve();
                } else if (attempts >= maxAttempts) {
                    reject(new Error('企业微信SDK加载超时'));
                } else {
                    setTimeout(checkWx, 100);
                }
            };
            
            checkWx();
        });
    }
    
    /**
     * 创建模拟的wx对象（用于开发测试）
     * @returns {Object} 模拟的wx对象
     */
    createMockWxObject() {
        return {
            config: (config) => {
                window.AppUtils.log('模拟wx.config调用:', config);
                setTimeout(() => {
                    if (window.wx.ready) {
                        window.wx.ready();
                    }
                }, 100);
            },
            ready: null,
            error: null,
            checkJsApi: (params) => {
                window.AppUtils.log('模拟wx.checkJsApi调用:', params);
                if (params.success) {
                    params.success({
                        checkResult: params.jsApiList.reduce((result, api) => {
                            result[api] = true;
                            return result;
                        }, {})
                    });
                }
            },
            invoke: (api, params, callback) => {
                window.AppUtils.log(`模拟wx.invoke调用: ${api}`, params);
                
                setTimeout(() => {
                    if (api === 'getCurExternalContact') {
                        // 模拟获取外部联系人
                        const mockResult = {
                            err_code: 0,
                            err_msg: 'ok',
                            userId: 'mock_external_user_' + Math.random().toString(36).substr(2, 9)
                        };
                        if (callback) callback(mockResult);
                        if (params.success) params.success(mockResult);
                    } else if (api === 'getContext') {
                        // 模拟获取上下文
                        const mockResult = {
                            err_code: 0,
                            err_msg: 'ok',
                            entry: 'single_chat_tools', // 单聊工具
                            chatType: 'single'
                        };
                        if (callback) callback(mockResult);
                        if (params.success) params.success(mockResult);
                    } else {
                        // 其他API的通用模拟
                        const mockResult = {
                            err_code: 0,
                            err_msg: 'ok'
                        };
                        if (callback) callback(mockResult);
                        if (params.success) params.success(mockResult);
                    }
                }, 200);
            },
            agentConfig: (config) => {
                window.AppUtils.log('模拟wx.agentConfig调用:', config);
                setTimeout(() => {
                    if (window.wx.ready) {
                        window.wx.ready();
                    }
                }, 100);
            }
        };
    }
    
    /**
     * 获取JSSDK配置
     * @returns {Promise} 配置Promise
     */
    async getJsSdkConfig() {
        const currentUrl = window.location.href.split('#')[0]; // 去掉hash部分
        
        try {
            const response = await window.API.getJsSdkConfig(currentUrl);
            return response.data.data;
        } catch (error) {
            window.AppUtils.error('获取JSSDK配置失败:', error);
            throw error;
        }
    }
    
    /**
     * 配置企业微信JSSDK
     * @param {Object} config - JSSDK配置
     * @returns {Promise} 配置Promise
     */
    configureJsSDK(config) {
        return new Promise((resolve, reject) => {
            window.AppUtils.log('配置企业微信JSSDK:', config);
            
            // 设置ready回调
            window.wx.ready = () => {
                window.AppUtils.log('企业微信JSSDK ready');
                resolve();
            };
            
            // 设置error回调
            window.wx.error = (res) => {
                window.AppUtils.error('企业微信JSSDK error:', res);
                reject(new Error(`JSSDK配置失败: ${res.errMsg || '未知错误'}`));
            };
            
            // 调用wx.config
            window.wx.config({
                beta: config.beta || false,
                debug: config.debug || false,
                appId: config.appId,
                timestamp: config.timestamp,
                nonceStr: config.nonceStr,
                signature: config.signature,
                jsApiList: config.jsApiList || window.AppConfig.wechat.jsApiList
            });
        });
    }
    
    /**
     * 获取当前外部联系人ID
     * @returns {Promise<string>} 外部联系人ID
     */
    async getCurrentExternalContact() {
        if (!this.isInitialized) {
            throw new Error('JSSDK未初始化');
        }
        
        return new Promise((resolve, reject) => {
            window.AppUtils.log('获取当前外部联系人ID');
            
            window.wx.invoke('getCurExternalContact', {}, (res) => {
                window.AppUtils.log('getCurExternalContact结果:', res);
                
                if (res.err_code === 0) {
                    resolve(res.userId);
                } else {
                    reject(new Error(`获取外部联系人ID失败: ${res.err_msg || '未知错误'}`));
                }
            });
        });
    }
    
    /**
     * 获取当前上下文信息
     * @returns {Promise<Object>} 上下文信息
     */
    async getContext() {
        if (!this.isInitialized) {
            throw new Error('JSSDK未初始化');
        }
        
        return new Promise((resolve, reject) => {
            window.AppUtils.log('获取当前上下文信息');
            
            window.wx.invoke('getContext', {}, (res) => {
                window.AppUtils.log('getContext结果:', res);
                
                if (res.err_code === 0) {
                    resolve({
                        entry: res.entry,
                        chatType: res.chatType
                    });
                } else {
                    reject(new Error(`获取上下文失败: ${res.err_msg || '未知错误'}`));
                }
            });
        });
    }
    
    /**
     * 检查JS接口是否可用
     * @param {Array<string>} jsApiList - 要检查的接口列表
     * @returns {Promise<Object>} 检查结果
     */
    async checkJsApi(jsApiList) {
        if (!this.isInitialized) {
            throw new Error('JSSDK未初始化');
        }
        
        return new Promise((resolve, reject) => {
            window.wx.checkJsApi({
                jsApiList: jsApiList,
                success: (res) => {
                    window.AppUtils.log('checkJsApi成功:', res);
                    resolve(res.checkResult);
                },
                fail: (res) => {
                    window.AppUtils.error('checkJsApi失败:', res);
                    reject(new Error(`检查JS接口失败: ${res.errMsg || '未知错误'}`));
                }
            });
        });
    }
    
    /**
     * 获取用户身份信息
     * @returns {Promise<Object>} 用户信息
     */
    async getUserInfo() {
        try {
            // 从URL参数中获取code
            const urlParams = new URLSearchParams(window.location.search);
            const code = urlParams.get('code');
            
            if (!code && !window.AppConfig.development.enableMockData) {
                throw new Error('未找到授权码，请通过企业微信正确访问');
            }
            
            // 调用API获取用户信息
            const response = await window.API.getUserInfo(code || 'mock_code');
            this.userInfo = response.data.data;
            
            // 触发用户信息就绪事件
            this.emit('userInfoReady', this.userInfo);
            
            window.AppUtils.log('用户信息获取成功:', this.userInfo);
            return this.userInfo;
        } catch (error) {
            window.AppUtils.error('获取用户信息失败:', error);
            throw error;
        }
    }
    
    /**
     * 添加事件监听器
     * @param {string} event - 事件名称
     * @param {Function} listener - 监听器函数
     */
    on(event, listener) {
        if (this.listeners[event]) {
            this.listeners[event].push(listener);
        }
    }
    
    /**
     * 移除事件监听器
     * @param {string} event - 事件名称
     * @param {Function} listener - 监听器函数
     */
    off(event, listener) {
        if (this.listeners[event]) {
            const index = this.listeners[event].indexOf(listener);
            if (index > -1) {
                this.listeners[event].splice(index, 1);
            }
        }
    }
    
    /**
     * 触发事件
     * @param {string} event - 事件名称
     * @param {*} data - 事件数据
     */
    emit(event, data) {
        if (this.listeners[event]) {
            this.listeners[event].forEach(listener => {
                try {
                    listener(data);
                } catch (error) {
                    window.AppUtils.error(`事件监听器执行错误 (${event}):`, error);
                }
            });
        }
    }
    
    /**
     * 获取当前配置
     * @returns {Object} 当前配置
     */
    getConfig() {
        return this.config;
    }
    
    /**
     * 获取当前用户信息
     * @returns {Object} 当前用户信息
     */
    getCurrentUserInfo() {
        return this.userInfo;
    }
    
    /**
     * 检查是否已初始化
     * @returns {boolean} 是否已初始化
     */
    isReady() {
        return this.isInitialized;
    }
    
    /**
     * 检查是否在企业微信环境中
     * @returns {boolean} 是否在企业微信环境
     */
    isInWeChatWorkEnvironment() {
        return this.isInWeChatWork;
    }
}

// 创建企业微信服务实例
window.WeChatWork = new WeChatWorkService();

// 工具函数
window.WeChatUtils = {
    /**
     * 自动初始化企业微信JSSDK
     * @param {Object} options - 初始化选项
     * @returns {Promise} 初始化Promise
     */
    async autoInit(options = {}) {
        try {
            await window.WeChatWork.initialize(options);
            return true;
        } catch (error) {
            window.AppUtils.error('自动初始化失败:', error);
            return false;
        }
    },
    
    /**
     * 获取客户ID（优先从URL参数，其次从企业微信接口）
     * @returns {Promise<string>} 客户ID
     */
    async getCustomerId() {
        try {
            // 1. 先从URL参数中获取
            const urlParams = new URLSearchParams(window.location.search);
            let customerId = urlParams.get('external_userid') || urlParams.get('externalUserId');
            
            if (customerId) {
                window.AppUtils.log('从URL参数获取到客户ID:', customerId);
                return customerId;
            }
            
            // 2. 从企业微信接口获取
            if (window.WeChatWork.isReady()) {
                customerId = await window.WeChatWork.getCurrentExternalContact();
                if (customerId) {
                    window.AppUtils.log('从企业微信接口获取到客户ID:', customerId);
                    return customerId;
                }
            }
            
            // 3. 如果是开发环境，返回模拟ID
            if (window.AppConfig.development.enableMockData) {
                customerId = 'mock_external_user_' + Math.random().toString(36).substr(2, 9);
                window.AppUtils.log('使用模拟客户ID:', customerId);
                return customerId;
            }
            
            throw new Error('无法获取客户ID');
        } catch (error) {
            window.AppUtils.error('获取客户ID失败:', error);
            throw error;
        }
    },
    
    /**
     * 检查当前环境和权限
     * @returns {Object} 环境检查结果
     */
    checkEnvironment() {
        const result = {
            isInWeChatWork: window.WeChatWork.isInWeChatWorkEnvironment(),
            isInitialized: window.WeChatWork.isReady(),
            isMockMode: window.AppConfig.development.enableMockData,
            userAgent: navigator.userAgent,
            currentUrl: window.location.href
        };
        
        window.AppUtils.log('环境检查结果:', result);
        return result;
    }
};

// 调试信息
if (window.AppConfig.development.enableDebugLog) {
    window.AppUtils.log('企业微信服务已初始化');
    window.AppUtils.log('环境检测:', {
        isInWeChatWork: window.WeChatWork.isInWeChatWorkEnvironment(),
        userAgent: navigator.userAgent
    });
}